import 'dart:async';
import 'dart:io';
import 'package:flutter/foundation.dart';
import 'device_config_service.dart';

class DedicatedDeviceMonitorService {
  static Timer? _monitorTimer;
  static bool _isMonitoring = false;
  static const Duration _checkInterval = Duration(seconds: 20);
  
  // 开始监控专用设备路径
  static Future<void> startMonitoring() async {
    if (_isMonitoring) {
      debugPrint('专用设备监控已在运行中');
      return;
    }
    
    final isDedicated = await DeviceConfigService.isDedicatedDevice();
    if (!isDedicated) {
      debugPrint('非专用设备模式，跳过监控启动');
      return;
    }
    
    debugPrint('开始专用设备监控，每20秒检测一次...');
    _isMonitoring = true;
    
    // 立即执行一次检测
    await _performMonitorCheck();
    
    // 启动定时器
    _monitorTimer = Timer.periodic(_checkInterval, (timer) async {
      await _performMonitorCheck();
    });
  }
  
  // 停止监控
  static void stopMonitoring() {
    if (!_isMonitoring) {
      debugPrint('专用设备监控未运行');
      return;
    }
    
    debugPrint('停止专用设备监控');
    _isMonitoring = false;
    _monitorTimer?.cancel();
    _monitorTimer = null;
  }
  
  // 重启监控（先停止再启动）
  static Future<void> restartMonitoring() async {
    stopMonitoring();
    await startMonitoring();
  }
  
  // 检查是否在监控中
  static bool get isMonitoring => _isMonitoring;
  
  // 执行一次监控检测
  static Future<Map<String, dynamic>?> _performMonitorCheck() async {
    try {
      final isDedicated = await DeviceConfigService.isDedicatedDevice();
      if (!isDedicated) {
        debugPrint('当前非专用设备模式，停止监控');
        stopMonitoring();
        return null;
      }
      
      final dedicatedPath = await DeviceConfigService.getDedicatedDevicePath();
      final dir = Directory(dedicatedPath);
      
      // 检查路径权限和存在性
      bool dirExists = false;
      try {
        dirExists = await dir.exists();
      } catch (e) {
        debugPrint('无法访问专用设备路径 $dedicatedPath: $e');
        // 权限问题，跳过本次检测但不停止监控
        return null;
      }
      
      if (!dirExists) {
        debugPrint('专用设备路径不存在: $dedicatedPath');
        return null;
      }
      
      // 获取目录下所有Excel文件
      List<File> allFiles = [];
      try {
        allFiles = dir
            .listSync()
            .whereType<File>()
            .where((f) {
              final name = f.path.toLowerCase();
              return name.endsWith('.xlsx') || name.endsWith('.xls');
            })
            .toList();
      } catch (e) {
        debugPrint('无法列出专用设备路径下的文件: $e');
        // 权限问题，跳过本次检测
        return null;
      }
      
      if (allFiles.isEmpty) {
        debugPrint('专用设备路径下无Excel文件');
        return null;
      }
      
      // 检查是否需要重新加载数据
      final shouldReload = await DeviceConfigService.shouldReloadExamData(allFiles);
      if (!shouldReload) {
        // 文件未变化，无需处理
        return null;
      }
      
      debugPrint('检测到专用设备路径下有新的或修改的Excel文件，开始自动加载...');
      
      // 执行自动加载
      final result = await DeviceConfigService.loadFromDedicatedPath();
      
      if (result['success'] == true) {
        debugPrint('专用设备自动加载成功: ${result['message']}');
      } else {
        debugPrint('专用设备自动加载失败: ${result['message']}');
      }
      
      return result;
      
    } catch (e) {
      debugPrint('专用设备监控检测出错: $e');
      return {
        'success': false,
        'message': '监控检测出错: $e',
        'details': []
      };
    }
  }
  
  // 手动触发一次检测（供外部调用）
  static Future<Map<String, dynamic>?> performManualCheck() async {
    debugPrint('执行手动专用设备检测...');
    return await _performMonitorCheck();
  }
  
  // 获取监控状态信息
  static Map<String, dynamic> getMonitorStatus() {
    return {
      'isMonitoring': _isMonitoring,
      'checkInterval': _checkInterval.inSeconds,
      'nextCheckIn': _monitorTimer != null 
          ? _checkInterval.inSeconds - (DateTime.now().millisecondsSinceEpoch ~/ 1000) % _checkInterval.inSeconds
          : null,
    };
  }
} 